import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringExtractor {
    // 正则表达式模式，用于匹配双引号之间的字符串，考虑转义字符
    private static final String STRING_PATTERN = "\"(([^\"\\\\]|\\\\.)*)\"";
    private static final Pattern pattern = Pattern.compile(STRING_PATTERN);

    public static void main(String[] args) {
        if (args.length != 1) {
            System.out.println("Usage: java StringExtractor <file-path>");
            return;
        }

        String filePath = args[0];
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            StringBuilder content = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                content.append(line).append("\n");
            }

            String contentStr = content.toString();
            Matcher matcher = pattern.matcher(contentStr);

            while (matcher.find()) {
                String rawString = matcher.group(1);
                String processedString = processEscapes(rawString);
                System.out.println(processedString);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 处理转义字符的方法
    private static String processEscapes(String rawString) {
        StringBuilder processedString = new StringBuilder();
        for (int i = 0; i < rawString.length(); i++) {
            char c = rawString.charAt(i);
            if (c == '\\' && i + 1 < rawString.length()) {
                char nextChar = rawString.charAt(i + 1);
                switch (nextChar) {
                    case '"':
                        processedString.append('"');
                        i++; // 跳过下一个字符，因为它是一个转义字符的一部分
                        break;
                    case '\\':
                        processedString.append('\\');
                        i++; // 跳过下一个字符，因为它是一个转义字符的一部分
                        break;
                    case 'n':
                        processedString.append('\n');
                        i++; // 跳过下一个字符，因为它是一个转义字符的一部分
                        break;
                    case 'r':
                        processedString.append('\r');
                        i++; // 跳过下一个字符，因为它是一个转义字符的一部分
                        break;
                    case 't':
                        processedString.append('\t');
                        i++; // 跳过下一个字符，因为它是一个转义字符的一部分
                        break;
                    // 可以根据需要添加更多的转义字符处理
                    default:
                        // 如果遇到未知的转义序列，可以保留原样或抛出异常
                        processedString.append('\\').append(nextChar);
                        i++; // 跳过下一个字符，因为它是一个转义字符的一部分
                        break;
                }
            } else {
                processedString.append(c);
            }
        }
        return processedString.toString();
    }
}
